/*
 * @Description: 
 * @Version: 2.0
 * @Autor: wangmiao
 * @Date: 2022-10-20 15:54:45
 * @LastEditors: wangmiao
 * @LastEditTime: 2022-10-21 13:22:25
 */

import { Agent } from "http"
import { type } from "os"
import { inflate } from "zlib"


interface animalInfo{
  name: string,
  age?: number,
  weight?: number,
  color: string,
  hobby?: Array<string>
}

interface catInfo{
  name: string,
  color: ''
}

interface dogInfo{
  name: string,
  hobby: Array<string>
}


// const catInfo: Pick<animalInfo, 'name' | 'color'> = {
//   name: '小明',
//   color: 'white'
// }

// const dog: Pick<animalInfo, 'name' | 'hobby'> = {
//   name: '小王',
//   hobby: ['跑步', '游泳']
// }


// Partial

// type myPartial<T> = {
//   [p in keyof T] ?: T[p]
// }

// const catInfo: myPartial<animalInfo> = {
//   name: '小明',
//   color: 'white'
// }


// Pick

// type myPick<T, K extends keyof T> = {
//   [P in K] : T[P]
// }

// const catInfo: myPick<animalInfo, 'name' | 'color'> = {
//   name: '小明',
//   color: 'white'
// }


// Required

// type myRequired<T> = {
//   [P in keyof T] -?: T[P]
// }

// const catInfo: myRequired<animalInfo> = {
//   name: '小明',
//   color: 'white',
//   age: 18,
//   weight: 10,
//   hobby: ['游泳']
// }


// Readonly

// type myReadonly<T> = {
//   readonly [P in keyof T] : T[P]
// }

// const catInfo: myReadonly<animalInfo> = {
//   name: '小明',
//   color: 'white',
// }

// catInfo.name = '小王'


// Record

// type myRecord<K extends keyof any, T> = {
//   [P in  K] : T
// }

// type propsInfo = 'name' | 'color'

// const propsValue: myRecord<propsInfo, string> = {
//   name: '小明',
//   color: 'white'
// }


// Exclude

type myExclude<T, U> = T extends U ? never : T

// type name = myExclude<'小明' | '小杨', '小刚' | '小明'>

// // 相当于

// type name = '小杨'


// Extract

// type myExtract<T, U> = T extends U ? T : never

// type name = myExtract<'小明' | '小杨', '小刚' | '小明'>

// // 相当于

// type name = '小明'


// Omit

// type myOmit<T, K extends keyof T> = Pick<T, myExclude<keyof T, K>>

// const propsValue: myOmit<animalInfo, 'name' | 'age'> = {
//   name: '小明',
//   color: 'white'
// }


// ReturnType

// type myReturnType<T> = T extends (...arg: any) => infer R ? R : any

// function returnPrams(x: number, y: number): number{
//   return x + y
// }
// type prams = myReturnType<typeof returnPrams>

// const num: prams = 3232


// MyParameters

// type MyParameters<T> = T extends (...arg: infer R) => void ? R : any

// function returnPrams(x: number, y: string): string{
//   return x + y
// }
// type prams = MyParameters<typeof returnPrams>

// const num: prams = [123, '321']


// keyof

// interface animalInfo{
//   name: string,
//   age?: number,
//   weight?: number,
//   color: string,
//   hobby?: Array<string>
// }
// 相当于

// type animalInfo = 'name' | 'age' | 'weight' | 'color' | 'hobby'


// extends

// interface A{
//   name: string
// }

// interface B{
//   age: number
// }

// interface C extends A,B{
//   hobby: Array<string>
// }

// const info: C = {
//   name: '小明',
//   age: 18,
//   hobby: ['游泳']
// }

interface A{
  name: string,
  age: number
}

interface B{
  name: string
}

type C = A extends B ? A : B  // 此时A extends B为false，即这是C 等于A

